package com.study.qqserve.service;

import com.study.qqcommon.Message;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 历史消息缓存服务
 */
public class OfflineMessagesService{

    // 存储每个用户的历史消息
    private static final HashMap<String, LinkedList<Message>> historyMessagesCache = new HashMap<>();
    // 设置缓存容量限制
    private static final int MAX_HISTORY_MESSAGES = 100;
    // 锁，确保线程安全
    private static final Lock lock = new ReentrantLock();

    /**
     * 添加历史消息
     * @param userId  用户id
     * @param message 消息内容
     */
    public static void addOfflineMessage(String userId, Message message) {
        lock.lock();
        try {
            // 获取该用户的历史消息队列
            LinkedList<Message> userMessages = historyMessagesCache.computeIfAbsent(userId, k -> new LinkedList<>());

            // 添加新消息到队列
            userMessages.add(message);

            // 如果历史消息超过最大限制，移除最旧的消息（队列头部）
            if (userMessages.size() > MAX_HISTORY_MESSAGES) {
                userMessages.poll();
            }

            System.out.println("用户 " + userId + " 当前历史消息条数: " + userMessages);

        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取历史消息
     * @param userId 用户id
     * @return 用户的历史消息列表
     */
    public static List<Message> getHistoryMessages(String userId) {
        lock.lock();
        try {
            // 获取该用户的历史消息
            LinkedList<Message> userMessages = historyMessagesCache.get(userId);
            if (userMessages == null) {
                return Collections.emptyList();
            }
            return new ArrayList<>(userMessages); // 返回历史消息的副本
        } finally {
            lock.unlock();
        }
    }

    /**
     * 清除某用户的历史消息
     * @param userId 用户id
     */
    public static void clearHistoryMessages(String userId) {
        lock.lock();
        try {
            historyMessagesCache.remove(userId);
            System.out.println("已清除用户 " + userId + " 的历史消息.");
        } finally {
            lock.unlock();
        }
    }

    //获取所有消息
    public static HashMap<String, LinkedList<Message>> getHistoryMessagesCache() {
        return historyMessagesCache;
    }

    /**
     * 删除超过限制的历史消息（手动触发，适用于批量清理）
     */
    public static void cleanUpHistoryMessages() {
        lock.lock();
        try {
            Iterator<Map.Entry<String, LinkedList<Message>>> iterator = historyMessagesCache.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, LinkedList<Message>> entry = iterator.next();
                if (entry.getValue().size() > MAX_HISTORY_MESSAGES) {
                    // 删除超过限制的历史消息
                    entry.getValue().poll();
                    System.out.println("清理了 " + entry.getKey() + " 的历史消息，保持最新 " + MAX_HISTORY_MESSAGES + " 条消息.");
                }
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 发送离线消息
     * @param userId 用户id
     */

    public static void sendOfflineMessage(String userId) throws IOException {
        lock.lock();
        try {
            ObjectOutputStream oss = MangerClientThreads.getServerContentThread(userId).getObjectOutputStream();
            // 获取离线消息
            List<Message> offlineMessages = getHistoryMessages(userId);
            // 发送离线消息
            for (Message message : offlineMessages) {
                oss.writeObject(message);
                System.out.println("发送离线消息给用户 " + userId + ": " + message);
                oss.flush();
            }

            // 发送完毕后清除历史消息
            clearHistoryMessages(userId);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
